-------------------------------------------------------------------------------------
-- -*- coding: utf-8 -*-
--
-- @author:   zxf
-- @email:    07291@qq.com
-- @date:     2024/5/30
-- @module:   item
-- @describe:
-- @version:  v1.0
--

-------------------------------------------------------------------------------------

---@class item
local item = {}
local this = item

local item_unit = item_unit
local item_ctx = item_ctx
local exchange_unit = exchange_unit
local exchange_ctx = exchange_ctx
local npc_shop_unit = npc_shop_unit
local npc_shop_ctx = npc_shop_ctx
local main_ctx = main_ctx
local local_player = local_player
---@type shop_cfg
local shop_cfg = import("game/config/shop_cfg")
---@type equip_cfg
local equip_cfg = import("game/config/equip_cfg")
---@type item_cfg
local item_cfg = import("game/config/item_cfg")
---@type antique_cfg
local antique_cfg = import("game/config/antique_cfg")
---@type api
local api = import("api/api")
---@type utils
local utils = import("base/utils")
---@type configer
local configer = import("base/configer")
---@type common
local common = import("game/func/common")
-- 获取背包中的道具(有同名时只返回第一个查找到的道具)
-- kind 0/所有 1/装备中
-- name 物品名字
-- findExpiration 是否查找过期物品
function this.get_item_in_bag_by_name(kind, name, findExpiration, close_vague)
    local list = item_unit.list(kind)
    local ret
    for i = 1, #list do
        if item_ctx:init(list[i]) then
            local isFind = false
            local is_expiration = item_ctx:is_expiration()
            if not close_vague then
                if string.find(item_ctx:name(), name) then
                    if not is_expiration or findExpiration then
                        isFind = true
                    end
                end
            else
                if item_ctx:name() == name then
                    if not is_expiration or findExpiration then
                        isFind = true
                    end
                end
            end
            if isFind then
                ret = {
                    obj = list[i],
                    id = item_ctx:id(),
                    res_id = item_ctx:res_id(),
                    type = item_ctx:type(),
                    num = item_ctx:num(),
                    quality = item_ctx:quality(),
                    weight = item_ctx:weight(),
                    equip_type = item_ctx:equip_type(),
                    equip_job = item_ctx:equip_job(),           -- 副武器好像不一样
                    enhanced_level = item_ctx:enhanced_level(), --强化等级
                    name = item_ctx:name(),
                    is_damage = item_ctx:is_damage(),
                    is_expiration = item_ctx:is_expiration(), --物品过期
                }
                break
            end
        end
    end
    return ret
end

-- 得到背包列表 setType == -1 不限类型
-----------------------------------------------------
---@param kind number 所有/0 装备中/1
---@param setType number 类型
---@param name string 名字
---@param findExpiration boolean 是否查找过期物品
-----------------------------------------------------
function this.get_item_list(kind, setType, name, findExpiration)
    local list = item_unit.list(kind)
    local ret = nil
    for i = 1, #list do
        if item_ctx:init(list[i]) then
            local isFind = false
            local is_expiration = item_ctx:is_expiration()
            if setType == -1 or setType == item_ctx:type() then
                if name and string.find(item_ctx:name(), name) or not name then
                    if not is_expiration or findExpiration then
                        isFind = true
                    end
                end
            end
            if isFind then
                if not ret then
                    ret = {}
                end
                table.insert(ret, {
                    obj = list[i],
                    id = item_ctx:id(),
                    res_id = item_ctx:res_id(),
                    type = item_ctx:type(),
                    num = item_ctx:num(),
                    quality = item_ctx:quality(),
                    weight = item_ctx:weight(),
                    equip_type = item_ctx:equip_type(),
                    equip_job = item_ctx:equip_job(),           -- 副武器好像不一样
                    enhanced_level = item_ctx:enhanced_level(), --强化等级
                    name = item_ctx:name(),
                    is_damage = item_ctx:is_damage(),
                    is_expiration = item_ctx:is_expiration(), --物品过期
                })
            end
        end
    end
    return ret
end

-- 获取货币数量通过名字
function this.get_money_num_by_name(name)
    local cfg = shop_cfg.MONEY_CONFIG[name]
    if cfg then
        return item_unit.get_money_byid(cfg)
    end
    return 0
end

-- 获得药物配置
function this.get_potion_config_by_name(name)
    return shop_cfg.BUY_ITEM_INFO[name]
end

-- 找装备配置
function this.find_equip_config(tmpData)
    local cfg = equip_cfg.EQUIP_TYPE
    for _, v in pairs(cfg) do
        if tmpData.equip_type == v.equip_type then
            return v
        end
    end
    return nil
end

------------------------------------------------------------------------------------
-- 根据传入的物品名取背包中查询是否有该物品，有则返回true，反之返回false
---[读取] 根据物品名判断背包中是否有该物品
---@param   item_name  string  需要找寻的物品
---@return  boolean
------------------------------------------------------------------------------------
function this.is_have_item(item_name)
    -- 获取背包中的物品
    local bag_item_list = this.get_bag_item_list()
    -- 返回情况
    local result = false

    for _, value in pairs(bag_item_list) do
        --if not decider.is_working() then
        --    return false, "脚本停止 ，查询终止"
        --end

        if string.find(value.name, item_name) then
            result = true
            break
        end
    end

    return result
end

-------------------------------------------------------------------------------------
-- [读取] 根据商品名和价格获取要购买的商品的id(npc商店)
-------------------------------------------------------------------------------------
function this.get_shop_item_id_by_name_and_price(item_name, price)
    -- 获取所有商品信息
    local shop_item_list = this.get_shop_item_list()
    --print_r(shop_item_list)

    -- 根据商品名获取到商品id
    for k, v in pairs(shop_item_list) do
        if v.name == item_name and v.price == price then
            --print_r(v)
            xxmsg("商品名:" .. v.name .. "价格:" .. v.price)
            return v.id
        end
        --if v.name == item_name and v.price == price and v.can_buy then
        --    xxmsg(111)
        --    print_r(v)
        --    -- 如果该商品名字和价格对得上并且能够购买就返回id
        --    return v.id
        --elseif v.name == item_name and v.price == price and not v.can_buy then
        --    xxmsg(222)
        --    print_r(v)
        --    -- 如果该商品名字和价格对得上但是限制购买（一个服务器一天只能买一次）就返回false
        --    return false, "该物品限制购买"
        --end
    end

    return false
end

-------------------------------------------------------------------------------------
-- [读取] 封装npc商品
-------------------------------------------------------------------------------------
function this.get_shop_item_list()
    local list = npc_shop_unit.list()
    local shop_item_list = {}

    --xxmsg("NPC商品总数:"..#list)   [name] => "生命护身符（归属）"
    for i = 1, #list do
        local obj = list[i]
        if npc_shop_ctx:init(obj) then
            --local can_buy = false
            --if npc_shop_ctx:name() == "生命护身符（归属）" then
            --    can_buy = npc_shop_ctx:can_buy()
            --end
            local item = {
                obj = obj,
                res_ptr = npc_shop_ctx:res_ptr(),
                id = npc_shop_ctx:id(),
                res_id = npc_shop_ctx:res_id(),
                type = npc_shop_ctx:type(),
                price = npc_shop_ctx:price(),
                --can_buy = npc_shop_ctx:can_buy(),
                name = npc_shop_ctx:name()
            }
            table.insert(shop_item_list, item)
        end
    end

    return shop_item_list
end

-- 通过名字找
function this.find_data_by_name(itemList, name, vague)
    local ret = nil
    for _, v in ipairs(itemList) do
        if vague then
            if string.find(v.name, name) then
                if not ret then
                    ret = {}
                end
                table.insert(ret, v)
            end
        else
            if v.name == name then
                if not ret then
                    ret = {}
                end
                table.insert(ret, v)
            end
        end
    end
    return ret
end

-- 通过id找
function this.find_data_by_id(itemList, id)
    for _, v in ipairs(itemList) do
        if v.id == id then
            return v
        end
    end
    return nil
end

-- 通过res_id找
function this.find_data_by_res_id(itemList, res_id)
    for _, v in ipairs(itemList) do
        if v.res_id == res_id then
            return v
        end
    end
    return nil
end

-- 通过方法查找
function this.find_data_by_func(itemList, func)
    for _, v in ipairs(itemList) do
        if func(v) then
            return v
        end
    end
    return nil
end

-- 使用道具
function this.use_item(itemObj, num)
    if item_ctx:init(itemObj) then
        if not item_ctx:is_expiration() then
            item_unit.use_item(item_ctx:id(), num)
            return true
        end
    end
    return false
end

------------------------------------------------------------------------------------
-- 根据物品的id到背包中遍历物品，如果id一样则返回其数量
---[读取] 根据传入的id获取该物品在背包中的数量
---@param   item_id  number  物品的id
---@return  number
------------------------------------------------------------------------------------
function this.get_item_num_by_id(item_id)
    -- 获取背包中的物品
    local bag_list = api.get_item_bag_list(0)
    local num = 0
    -- 遍历背包，根据id找到该物品的数量
    for _, v in pairs(bag_list) do
        if item_id == v.id then
            num = num + v.num
        end
    end
    return num
end

-------------------------------------------------------------------------------------
-- [读取] 根据物品名获取背包中的物品信息
-------------------------------------------------------------------------------------
function this.get_item_info_by_name(item_name, vague, found_expiration)
    -- 模糊查找
    vague = vague or false
    -- 是否查找过期物品
    found_expiration = found_expiration or false
    local item_info = {}
    local item_list = api.get_item_info(0)
    -- 判断是否为模糊查询
    if vague then
        for i = 1, #item_list do
            --print_r(item_list[i])
            -- 开启模糊查找
            if string.find(item_list[i].name, item_name) then
                -- 不查找过期物品
                if not found_expiration then
                    if not item_list[i].is_expiration then
                        item_info = item_list[i]
                    end
                else
                    --  [is_expiration] => true
                    --xxmsg(item_list[i].is_expiration)
                    item_info = item_list[i]
                end
            end
        end
    else
        for i = 1, #item_list do
            -- 精准查找
            if item_list[i].name == item_name then
                -- 不查找过期物品
                if not found_expiration then
                    if not item_list[i].is_expiration then
                        item_info = item_list[i]
                    end
                else
                    item_info = item_list[i]
                end
            end
        end
    end

    return item_info
end

function this.find_undecompose_equip(equip_name)
    return equip_cfg.CANT_DECOMPOSE_EQUIP[equip_name]
end

-- 判断传入的物品信息是否为执行装备类型 或则 是否为指定副武器 或则 是否为执行主武器
function this.is_equip(item_info, main_type, sub_type)
    local equip_list = equip_cfg.EQUIP_TYPE_V1
    local is_exist = false
    for k, v in pairs(equip_list) do
        if v.equip_type == item_info.equip_type then
            is_exist = true
            break
        end
    end
    if not is_exist then
        if item_info.equip_job == main_type or string.find(item_info.name, sub_type) then
            is_exist = true
        end
    end
    return is_exist
end

------------------------------------------------------------------------------------
-- [读取] 通过传入的装备id判断该装备是否已经穿戴
-- 根据传入的需要验证的装备的id和已经穿戴了的表进行对比，如果存在了就表示该装备已经被使用了，返回true，反之返回false
---@param   equip_id  number  装备id
---@return  boolean
------------------------------------------------------------------------------------
function this.equip_is_used(equip_id)
    -- 获取背包中所有物品表
    local bag_list = api.get_item_info(1)
    local result = false
    for _, item_info in pairs(bag_list) do
        if equip_id == item_info.id then
            result = true
        end
    end
    return result
end

------------------------------------------------------------------------------------
-- [读取] 通过传入的装备id判断该装备是否已经穿戴
-- 根据传入的需要验证的装备的id和已经穿戴了的表进行对比，如果存在了就表示该装备已经被使用了，返回true，反之返回false
---@param   equip_id  number  装备id
---@return  boolean
------------------------------------------------------------------------------------
function this.equip_is_used_v2(list, equip_id)
    -- 获取背包中所有物品表
    local result = false
    for _, item_info in ipairs(list) do
        if equip_id == item_info.id then
            result = true
            break
        end
    end
    return result
end

------------------------------------------------------------------------------------
-- 对背包中的物品进行筛选，如果物品包含归属和箱子两个字就不能上架
-- 如果正在使用就不能上架
-- 如果属于资源中不能上架的物品就不能上架
---[读取] 获取背包中的能够上架的物品列表
---@return  table
------------------------------------------------------------------------------------
function item.get_can_sell_item()
    local result_list = {}
    local filter_list = item_cfg.FILTER_UP_ITEM
    -- 获取背包中的所有物品
    local bag_list = api.get_item_info(0)
    local equip_list = api.get_item_info(1)
    -- 对物品进行筛选，包含归属两个字或者是箱子就不能上架
    for k, v in ipairs(bag_list) do
        if common.is_exist_time_list_arg(filter_list, v.name, true) or (not string.find(v.name, "（归属）") and not string.find(v.name, "箱子") and not string.find(v.name, "【活动】")) then
            -- 白装不上架
            local result_ex = true
            if item_cfg.UP_ITEM[v.name] then
                result_ex = true
            else
                if v.type == 0 and v.quality == 1 and (v.equip_type ~= 13 and v.equip_type ~= 14 and v.equip_type ~= 12 and v.equip_type ~= 15) then
                    result_ex = false
                end
            end
            if result_ex then
                -- 判断该物品是否正在使用，没有使用才可以加上架
                -- 获取该物品的id，判断其是否被使用
                local item_id = v.id
                if not item.equip_is_used_v2(equip_list, item_id) then
                    -- 判断该物品是否为不能上架的物品
                    local result = true
                    local not_exchange = item_cfg.NOT_EXCHANGE
                    result = not common.is_exist_list_arg(not_exchange, v.name, true)
                    --result = common.is_exist_list_arg(not_exchange, v.name, true)
                    --for i = 1, #not_exchange do
                    --    if not_exchange[i] == v.name then
                    --        result = false
                    --    end
                    --end
                    if result then
                        table.insert(result_list, v)
                        --xxmsg(v.name)
                    end
                end
            end
        end
    end

    return result_list
end

------------------------------------------------------------------------------------
---[读取] 封装搜索物品信息
---@return  table
------------------------------------------------------------------------------------
function item.get_exchange_search_list()
    local list = exchange_unit.list(0)
    local result_list = {}
    for i = 1, #list do
        --xxmsg(111)
        local obj = list[i]
        if exchange_ctx:init(obj) then
            local branch = {
                name = exchange_ctx:name(),
                id = exchange_ctx:id(),
                num = exchange_ctx:num(),
                type = exchange_ctx:type(),
                price = exchange_ctx:total_price(),
                average_price = (math.floor(exchange_ctx:total_price() / exchange_ctx:num() * 10000)) / 10000
            }
            table.insert(result_list, branch)
        end
    end
    return result_list
end

------------------------------------------------------------------------------------
---[读取] 封装搜索物品信息
---@return  table
------------------------------------------------------------------------------------
function item.get_exchange_sell_list()
    local list = exchange_unit.list(1)

    local result_list = {}
    for i = 1, #list do
        --xxmsg(111)
        local obj = list[i]
        if exchange_ctx:init(obj) then
            local up_time = math.floor(exchange_ctx:up_time() / 1000) + 1
            -- 是否可结算，0为未结算状态
            local batch_collect_time = exchange_ctx:batch_collect_time()
            local down_time = math.floor(batch_collect_time / 1000) + 1
            local branch = {
                name       = exchange_ctx:name(),
                id         = exchange_ctx:id(),
                num        = exchange_ctx:num(),
                sale_price = exchange_ctx:sale_price(),
                --status     = exchange_ctx:status(),
                type       = exchange_ctx:type(),
                up_time    = up_time,                           -- 公示时间
                down_time  = down_time,                         -- 可以结算时间
                down_time2 = utils.convert_datetime(down_time), -- 日期
                down_time3 = os.time() > down_time,             -- 是否能结算
                up_time2   = utils.convert_datetime(up_time),   -- 日期
                up_time3   = up_time < os.time(),               -- 布尔(是否可以查看到了)    }
                batch_collect_time   = batch_collect_time,
            }
            --print_r(branch)
            table.insert(result_list, branch)
        end
    end
    return result_list
end

------------------------------------------------------------------------------------
-- [读取] 根据物品名返回开箱序号
------------------------------------------------------------------------------------
function item.get_sel_idx_by_item_name(item_name)
    local sel_idx = -1
    for _, info in pairs(item_cfg.OPEN_MATERIAL_BOX) do
        for k, item_info in ipairs(info) do
            if item_info.item_name == item_name then
                sel_idx = item_info.sel_idx
                return sel_idx
            end
        end
    end
    return sel_idx
end

-- 根据名称获取背包中该物品的的数量(模糊查询)
function item.get_item_num_by_name(item_list, item_name)
    local num = 0
    for k, v in pairs(item_list) do
        if string.find(v.name, item_name) then
            num = num + v.num
        end
    end

    return num
end

-------------------------------------------------------------------------------------
-- [读取] 根据物品名获取商店中的物品信息
-- 通过物品名与价格进行匹配或者模糊匹配来搜索对应的商店中的物品信息
-------------------------------------------------------------------------------------
function this.get_shop_item_info_by_name(item_name, price, vague)
    -- 模糊查找
    vague = vague or false
    local item_info = {}
    local item_list = api.get_shop_info()
    --print_r(item_list)
    -- 判断是否为模糊查询
    if vague then
        for i = 1, #item_list do
            -- 如果物品列表中有该物品名,且价格相同，则返回该物品列表
            if string.find(item_list[i].name, item_name) and item_list[i].price == price then
                item_info = item_list[i]
            end
        end
    else
        for i = 1, #item_list do
            -- 精准查找
            if item_list[i].name == item_name and item_list[i].price == price then
                item_info = item_list[i]
            end
        end
    end

    return item_info
end

-------------------------------------------------------------------------------------
-- [读取] 根据商人名获取商人信息
-------------------------------------------------------------------------------------
function this.get_shop_info_by_name(npc_name)
    -- 获取角色周围的npc信息
    local npc_list = api.get_actor_info(2)

    for _, npc_info in pairs(npc_list) do
        -- 如果角色周围有该npc,并且npc名相同，则返回其npc信息表
        if this.have_shop_info_by_name(npc_name) and (npc_info.name == npc_name) then
            return npc_info
        end
    end
end

------------------------------------------------------------------------------------
-- [读取] 根据npc名判断周围是否有该npc信息
---@param npc_name string 商人名称
---@return boolean 是否有这个商人信息
------------------------------------------------------------------------------------
function this.have_shop_info_by_name(npc_name)
    local ret_b = false
    -- 获取角色周围的npc信息
    local npc_list = api.get_actor_info(2)

    for _, npc_info in pairs(npc_list) do
        -- 判断周围npc中是否有该npc名
        if npc_info.name == npc_name then
            ret_b = true
            break
        end
    end
    return ret_b
end

------------------------------------------------------------------------------------
-- [读取] 未使用物品的列表
-- 通过比较背包中所有物品表与已经使用物品表，来筛选出未使用物品的表
---@return  table   未使用物品的表
------------------------------------------------------------------------------------
function this.get_unused_equip_list()
    local all_items = api.get_item_info(0)  -- 所有物品
    local used_items = api.get_item_info(1) -- 正在使用的物品

    -- 创建一个映射，存储正在使用的装备
    local used_items_map = {}

    for _, used_item in ipairs(used_items) do
        used_items_map[used_item.id] = used_item
    end
    -- 创建一个表来存储未使用的物品
    local unused_items = {}

    -- 遍历所有物品，筛选出未使用的物品
    for _, item_info in ipairs(all_items) do
        if used_items_map[item_info.id] then
            -- 该物品正在使用，跳过
            goto next
        else
            -- 该物品未使用，添加到未使用物品表中
            table.insert(unused_items, item_info)
        end
        :: next ::
    end

    return unused_items
end

-------------------------------------------------------------------------------------
-- [读取] 根据物品名获取背包中未使用的物品信息,包括同名的物品
-------------------------------------------------------------------------------------
function this.get_item_info_by_unused_list(item_name, vague)
    -- 模糊查找
    vague = vague or false
    local item_info = {}
    local item_list = this.get_unused_equip_list()
    -- 判断是否为模糊查询
    if vague then
        for i = 1, #item_list do
            if not item_list[i].is_expiration then
                -- 开启模糊查找
                if string.find(item_list[i].name, item_name) then
                    table.insert(item_info, item_list[i])
                end
            end
        end
    else
        for i = 1, #item_list do
            if not item_list[i].is_expiration then
                -- 精准查找
                if item_list[i].name == item_name then
                    table.insert(item_info, item_list[i])
                end
            end
        end
    end

    return item_info
end

------------------------------------------------------------------------------------
-- [读取] 未使用物品的列表
-- 通过比较背包中所有物品表与已经使用物品表，来筛选出未使用物品的表
---@return  table   未使用物品的表
------------------------------------------------------------------------------------
function this.get_unused_item_list()
    local all_items = api.get_item_info(0)  -- 所有物品
    local used_items = api.get_item_info(1) -- 正在使用的物品

    -- 创建一个映射，存储正在使用的装备
    local used_items_map = {}
    --for _, used_item in ipairs(used_items) do
    --    used_items_map[used_item.name] = used_item.res_id
    --end
    for _, used_item in ipairs(used_items) do
        used_items_map[used_item.id] = used_item
    end
    -- 创建一个表来存储未使用的物品
    local unused_items = {}

    -- 遍历所有物品，筛选出未使用的物品
    for _, item_info in ipairs(all_items) do
        if used_items_map[item_info.id] then
            -- 该物品正在使用，跳过
            goto next
        else
            -- 该物品未使用，添加到未使用物品表中
            table.insert(unused_items, item_info)
        end
        :: next ::
    end

    return unused_items
end

--------------------------------------------------------------------------------------
-- [读取] 获取背包信息
--------------------------------------------------------------------------------------
function this.find_bag_item(item_type, item_res_id, item_level)
    local list = this.get_unused_item_list()
    for k, info in ipairs(list) do
        if info.type == item_type and info.enhanced_level == item_level and not info.is_damage and not info.is_expiration then
            if info.res_id == item_res_id then
                return info
            end
        end
    end
    return {}
end

------------------------------------------------------------------------------------------------------------------------
-- [读取] 获取背包中重复的装备
------------------------------------------------------------------------------------------------------------------------
function item.get_repetition_equip_list()
    local unused_items = this.get_unused_equip_list() -- 未使用的物品
    local used_items = api.get_item_bag_list(1)       -- 正在使用的物品
    local cant_decompose_equip = item_cfg.CANT_DECOMPOSE_EQUIP
    -- 创建一个映射
    local used_items_map = {}
    for _, used_item in ipairs(used_items) do
        used_items_map[used_item.name] = used_item.id
    end

    -- 创建一个表来存储背包中重复的装备
    local repetition_equip = {}

    -- 遍历所有物品，筛选出未使用的物品
    for _, item_info in ipairs(unused_items) do
        -- 如果物品名称在映射中存在且id相同，则该物品已使用
        if not cant_decompose_equip[item_info.name] and used_items_map[item_info.name] and used_items_map[item_info.name] ~= item_info.id then
            -- 背包中有同名装备，且id不同
            table.insert(repetition_equip, item_info)
        end
    end

    return repetition_equip
end

------------------------------------------------------------------------------------------------------------------------
-- [读取] 获取背包中重复的装备
------------------------------------------------------------------------------------------------------------------------
function item.get_repetition_equip_listV1()
    local unused_items = this.get_unused_equip_list() -- 未使用的物品
    local used_items = api.get_item_bag_list(1)       -- 正在使用的物品
    -- 创建一个映射
    local used_items_map = {}
    for _, used_item in ipairs(used_items) do
        used_items_map[used_item.name] = used_item.id
    end

    -- 创建一个表来存储背包中重复的装备
    local repetition_equip = {}

    -- 遍历所有物品，筛选出未使用的物品
    for _, item_info in ipairs(unused_items) do
        -- 如果物品名称在映射中存在且id相同，则该物品已使用
        if used_items_map[item_info.name] and used_items_map[item_info.name] ~= item_info.id then
            -- 背包中有同名装备，且id不同
            table.insert(repetition_equip, item_info)
        end
    end

    return repetition_equip
end

-------------------------------------------------------------------------------------
-- [读取] 封装物品中的信息
-------------------------------------------------------------------------------------
function item.get_bag_item_list(type)
    type = type or 0
    local list = item_unit.list(type)
    local bag_list = {}
    for i = 1, #list do
        local obj = list[i]
        -- xxmsg(i ..' '..obj..' '..tostring(item_ctx:init(obj)))
        if item_ctx:init(obj) then
            local result = {
                obj = obj,
                res_ptr = item_ctx:res_ptr(),
                id = item_ctx:id(),
                res_id = item_ctx:res_id(),
                type = item_ctx:type(),
                num = item_ctx:num(),
                quality = item_ctx:quality(),
                weight = item_ctx:weight(),
                equip_type = item_ctx:equip_type(),
                equip_job = item_ctx:equip_job(),
                enhanced_level = item_ctx:enhanced_level(),
                name = item_ctx:name(),
                is_damage = item_ctx:is_damage(),
                is_expiration = item_ctx:is_expiration(),
            }
            table.insert(bag_list, result)
        end
    end
    return bag_list
end

-------------------------------------------------------------------------------------
-- [读取] 获取损坏装备
-------------------------------------------------------------------------------------
function this.get_damage_equip(kind, findExpiration)
    local list = item_unit.list(kind)
    local ret = {}
    for i = 1, #list do
        if item_ctx:init(list[i]) then
            local isFind = false
            local is_damage = item_ctx:is_damage()
            if is_damage then
                local is_expiration = item_ctx:is_expiration()
                if not is_expiration or findExpiration then
                    isFind = true
                end
            end
            if isFind then
                local result = {
                    obj = list[i],
                    id = item_ctx:id(),
                    res_id = item_ctx:res_id(),
                    type = item_ctx:type(),
                    num = item_ctx:num(),
                    quality = item_ctx:quality(),
                    weight = item_ctx:weight(),
                    equip_type = item_ctx:equip_type(),
                    equip_job = item_ctx:equip_job(),
                    enhanced_level = item_ctx:enhanced_level(),
                    name = item_ctx:name(),
                    is_damage = item_ctx:is_damage(),
                    is_expiration = item_ctx:is_expiration(),
                }
                table.insert(ret, result)
            end
        end
    end
    return ret
end

------------------------------------------------------------------------------------
-- [读取] 根据物品名判断收藏分支中的该子项物品是否已收藏
------------------------------------------------------------------------------------
function item.is_can_collect_item_by_item_name(item_name)
    local collect_list = api.get_collection_info()
    for i, collect_info in ipairs(collect_list) do
        local sub_items = collect_info.sub_items
        -- 该分支未被收藏完成
        if not collect_info.is_finish then
            for idx, sub_item_info in ipairs(sub_items) do
                -- 根据名字匹配
                if item_name == sub_item_info.item_name then
                    if not sub_item_info.is_finish then
                        return true
                    end
                end
            end
        end
    end
    return false
end

------------------------------------------------------------------------------------
-- [读取] 根据自身背包中的物品判断未收藏的古董是否能打造
-- 读取用户ini中是否被标记，标记了则不打造，单角色限1次
------------------------------------------------------------------------------------
function item.is_can_make_up_item_by_bag(owner)
    -- 获取需要制造的古董列表
    local need_make_item = antique_cfg.INFO
    -- 获取背包列表
    local bag_list = api.get_item_info(0)
    local my_level = owner and owner.level or api.get_actor_level()
    local my_name = owner and owner.name or local_player:name()
    local my_money = api.get_item_money(3)
    for _, need_info in ipairs(need_make_item) do
        -- 获取古董名
        local need_name = need_info and need_info.antique_name or ""
        -- 需要的材料
        local need_item = need_info and need_info.need_item or {}
        -- 制造古董的最小等级
        local need_level = need_info and need_info.min_level or 999
        -- 能制造材料的计次
        local can_make_count = 0
        -- 需要的铜钱
        local need_money = need_info and need_info.money or 0
        if my_money - need_money < 100000 then
            -- 铜钱不够，遍历下一个
            goto next
        end
        if my_level < need_level then
            -- 等级不够则遍历下一个
            goto next
        end
        if not table.is_empty(need_item) then
            for material_idx, need_material_info in ipairs(need_item) do
                --print_r(need_material_info)
                -- 获取需要的材料名
                local material_name = need_material_info and need_material_info.name or ""
                -- 获取需要的数量
                local need_material_num = need_material_info and need_material_info.num or 0
                for i, bag_info in ipairs(bag_list) do
                    local bag_item_name = bag_info.name
                    local bag_item_num = bag_info.num
                    -- 判断需要的材料名字一样，数量足够，则加1
                    if bag_item_name == material_name and bag_item_num >= need_material_num then
                        can_make_count = can_make_count + 1
                    end
                end
                -- 如果需要的材料数量与计次都相等，说明可制造
                if #need_item == can_make_count then
                    local need_server = main_ctx:c_server_name()
                    -- 读取账号ini配置中的古董名字，判断是否被打造过，每个角色限打造一次
                    local is_make = configer.get_user_profile(need_server, my_name .. "_" .. need_name)
                    -- 判断可制造的物品是否已收藏
                    if this.is_can_collect_item_by_item_name(need_name) and is_make ~= "1" then
                        return true, need_name
                    end
                end
            end
        end
        :: next ::
    end
    return false
end

------------------------------------------------------------------------------------
-- [读取] 根据装备id获取装备信息
------------------------------------------------------------------------------------
function item.get_equip_info_by_id(init, name, id, res_id)
    local list = api.get_item_info(init)
    local bestEquipInfo = {}
    for _, v in ipairs(list) do
        if v.name == name and v.id == id and v.res_id == res_id then
            bestEquipInfo = v
            break
        end
    end
    return bestEquipInfo
end

return this
